/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package manejadores;

import com.akcess.exception.*;
import com.akcess.vo.*;
import com.akcess.impl.*;
import com.akcess.dao.*;
import java.sql.*;
import java.util.*;

/**
 * Esta clase se utiliza para realizar las tareas relacionadas con la gestion de los Roles,
 * como creacion, borrado y modificacion de rol, entre otras cosas.
 * @author Alejandro
 */
public class ManejadorRol {
    
    private Connection conexion = null;
    /**
     * Constructor de la Clase ManejadorRol que recibe una conexion a la BD.
     * @param con Conexion a la BD, el cual se utilizara como el unico atributo de esta clase. (Connection conexion)
     */
    public ManejadorRol(Connection con) {
        this.conexion = con;
    }   
    /**
     * Crea un Rol determinado en la BD.
     * @param rol Es un objeto de tipo Rol que contiene los datos del nuevo Rol.
     * @param modOper Es un objeto de tipo vector que contiene todos los modulos y las operaciones que se pueden
     * sobre dichos modulos, de modo a relacionar estos modulos con el Rol que se creara.
     * @throws com.akcess.exception.RolException Lanza excepciones del tipo RolException, creada por el DAOGenerator.
     */
    public void CrearRol(Rol rol, Vector modOper) throws RolException {
        try {            
            int id_nuevoRol = 0;            
            //Agrego a la base de datos la nueva solicitud
            RolDAOImpl manejadorRol = new RolDAOImpl();
            manejadorRol.insert(rol, this.conexion);
            Rol [] rolNuevo = manejadorRol.findByNombre(rol.getNombre(), this.conexion);
            id_nuevoRol = rolNuevo[0].getId_rol();

            //Para agregar a la tabla que relaciona el id del nuevo rol con los id de modulo y operacion
            Rol_tiene_modulo_tiene_operacioDAOImpl manejadorModOper = new Rol_tiene_modulo_tiene_operacioDAOImpl();
            Rol_tiene_modulo_tiene_operacio auxModOper = new Rol_tiene_modulo_tiene_operacio();
            Modulo_tiene_operacion operacion = null;
            for (int i = 0; i < modOper.size(); i++) {
                operacion = (Modulo_tiene_operacion) modOper.get(i);
                auxModOper.setId_modulo(operacion.getId_modulo());
                auxModOper.setId_permiso(operacion.getId_permiso());
                auxModOper.setId_rol((short) id_nuevoRol);
                manejadorModOper.insert(auxModOper, this.conexion);
            }      

        }  catch (RolException ex) {
            ex.printStackTrace();
        }  catch (Rol_tiene_modulo_tiene_operacioException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Realiza una validacion de modo a saber si la operacion es realizada sobre dicho modulo.
     * @param idModulo Indica el id del modulo.
     * @param idOper Indica el id de la operacion que se quiere realizar sobre dicho modulo.
     * @param nombreModOperRol Contiene todos los modulos y las operaciones que se pueden realizar en cada modulo.
     * @return true si puede realizarse esa operacion sobre el modulo, en otro caso false.
     * @throws com.akcess.exception.Modulo_tiene_operacionException Lanza excepciones del tipo Modulo_tiene_operacionException, creada por el DAOGenerator.
     */
    public boolean ValidarModOper(short idModulo, short idOper, NombresModulosOperaciones[] nombreModOperRol) throws Modulo_tiene_operacionException {
        boolean respuesta = false;       
        for (int i = 0; i < nombreModOperRol.length; i++) {
            if (nombreModOperRol[i].getId_permiso() == idOper && nombreModOperRol[i].getId_modulo() == idModulo) {
                respuesta = true;
                break;
            }
        }
        return respuesta;
    }
    /**
     * Obtiene todos los modulos existente y las operaciones que pueden realizarse en 
     * cada modulo.
     * @return Un vector del tipo Modulo_tiene_operacion, que relaciona el id de cada modulo con el id de cada operacion
     * que puede realizarse en dicho modulo.
     * @throws com.akcess.exception.Modulo_tiene_operacionException Lanza excepciones del tipo Modulo_tiene_operacionException, creada por el DAOGenerator.
     */
    public Modulo_tiene_operacion[] ObtenerModOper() throws Modulo_tiene_operacionException {
        Modulo_tiene_operacion[] modOper = null;
        try {
            Modulo_tiene_operacionDAOImpl modDAO = new Modulo_tiene_operacionDAOImpl();
            modOper = modDAO.findAll(this.conexion);
        } catch (Modulo_tiene_operacionException ex) {
            ex.printStackTrace();
        }
        return modOper;
    }
    /**
     * Obtiene todos los roles existentes en la BD.
     * @return Un vector de tipo Rol, que contiene toda la informacion de cada Rol.
     * @throws com.akcess.exception.RolException Lanza excepciones del tipo RolException, creada por el DAOGenerator.
     */
    public Rol[] ListarRoles() throws RolException {        
        Rol[] roles = null;
        try {
            RolDAOImpl rolDAO = new RolDAOImpl();
            roles = rolDAO.findAll(this.conexion);
        } catch (RolException ex) {
            ex.printStackTrace();
        }
        return roles;
    }

    /**
     * Realiza las modificaciones en la BD que fueron realizadas sobre un Rol determinado.
     * @param idRol Representa el id del Rol que fue modificado.
     * @param modOper Es un arreglo de tipo Vector que contiene los modulos modificados en el rol y las
     * operaciones modificadas en cada rol.
     * @throws com.akcess.exception.Rol_tiene_modulo_tiene_operacioException Lanza excepciones del tipo Rol_tiene_modulo_tiene_operacioException, creada por el DAOGenerator.
     */
    public void ModificarRol(int idRol, Vector modOper) throws Rol_tiene_modulo_tiene_operacioException {
        try {           
            Rol_tiene_modulo_tiene_operacioDAOImpl manejadorRolModOper = new Rol_tiene_modulo_tiene_operacioDAOImpl();
            Rol_tiene_modulo_tiene_operacio[] rolModOper = null;
            Rol_tiene_modulo_tiene_operacio auxRolModOper = new Rol_tiene_modulo_tiene_operacio();
            Modulo_tiene_operacion operacion = null;
            Rol_tiene_modulo_tiene_operacioPK rolModOperPK = new Rol_tiene_modulo_tiene_operacioPK();
            rolModOperPK.setId_rol((short) idRol);
            rolModOper = manejadorRolModOper.findById_rol((short) idRol, this.conexion);
            boolean band = false;
            int indice = 0;
            for (int i = 0; i < rolModOper.length; i++) {
                for (int j = 0; j < modOper.size(); j++) {
                    operacion = (Modulo_tiene_operacion) modOper.get(j);
                    if ((rolModOper[i].getId_modulo() == operacion.getId_modulo()) & (rolModOper[i].getId_permiso() == operacion.getId_permiso())) {
                        band = true;
                        indice = j;
                        break;
                    }
                }
                if (band) {
                    //borrar de vector
                    modOper.remove(indice);
                    band = false;
                } else {
                    //borrar de la base
                    rolModOperPK.setId_modulo(rolModOper[i].getId_modulo());
                    rolModOperPK.setId_permiso(rolModOper[i].getId_permiso());
                    manejadorRolModOper.delete(rolModOperPK, this.conexion);
                }
            }
            //Agregamos los nuevos permisos, esos solamente quedaran en el vector....
            for (int i = 0; i < modOper.size(); i++) {
                operacion = (Modulo_tiene_operacion) modOper.get(i);
                auxRolModOper.setId_modulo(operacion.getId_modulo());
                auxRolModOper.setId_permiso(operacion.getId_permiso());
                auxRolModOper.setId_rol((short) idRol);
                manejadorRolModOper.insert(auxRolModOper, this.conexion);
            }
           
        } catch (Rol_tiene_modulo_tiene_operacioException ex) {
            ex.printStackTrace();
        }
    }
    /**
     * Obtiene el id y nombre de los modulos relacionados con un Rol determinado, como tambien los id y nombres 
     * de los permisos u operaciones que puede realizarse sobre cada modulo.
     * @param idRol Contiene el id del Rol, del cual queremos obtener los modulos y permisos relacionados al mismo.
     * @return Retorna un arreglo de tipo NombresModulosOperaciones, que contiene toda la informacion de los modulos y operaciones de cada modulo.
     * @throws com.akcess.exception.RolException Lanza excepciones del tipo RolException, creada por el DAOGenerator.
     */
    public NombresModulosOperaciones[] ObtenerNombreModOper(int idRol) throws RolException {
        NombresModulosOperaciones[] rolModOper = null;
        try {            
            //Para agregar a la tabla que relaciona el id del nuevo rol con los id de modulo y operacion
            RolDAOImpl manejadorRolModOper = new RolDAOImpl();
            rolModOper = manejadorRolModOper.BuscarOperacionesXrol(idRol, this.conexion);
        } catch (RolException ex) {
            ex.printStackTrace();
        }
        return rolModOper;
    }
    /**
     * Obtiene el id y nombre de todos los modulos de la BD, como tambien los id y nombres 
     * de los permisos u operaciones que puede realizarse sobre cada modulo.     
     * @return Retorna un arreglo de tipo NombresModulosOperaciones, que contiene toda la informacion de los modulos y operaciones de cada modulo.
     * @throws com.akcess.exception.RolException Lanza excepciones del tipo RolException, creada por el DAOGenerator.
     */
    public NombresModulosOperaciones[] ObtenerNombreModOper() throws RolException {
        NombresModulosOperaciones[] nomModOper = null;
        try {
            //Para agregar a la tabla que relaciona el id del nuevo rol con los id de modulo y operacion
            Modulo_tiene_operacionDAOImpl manejadorModOper = new Modulo_tiene_operacionDAOImpl();
            nomModOper = manejadorModOper.BuscarOperacionesXMod(this.conexion);
        } catch (Modulo_tiene_operacionException ex) {
            ex.printStackTrace();
        }
        return nomModOper;
    }
    /**
     * Realiza el borrado de la BD de un Rol determinado.
     * @param idRol Contiene el id del Rol que sera eliminado.
     * @throws com.akcess.exception.RolException Lanza excepciones del tipo RolException, creada por el DAOGenerator.
     */
    public void BorrarRol(int idRol) throws RolException {   
             //Me conecto a la BD           
            RolPK rolPK = new RolPK();
            rolPK.setId_rol(idRol);
            RolDAOImpl manejadorRol = new RolDAOImpl();
            manejadorRol.delete(rolPK, this.conexion);
    }
}
